home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / cutpaste.lbr / PASTE.CQ / PASTE.C
Encoding:
C/C++ Source or Header  |  1985-06-03  |  11.6 KB  |  492 lines
  1. /*
  2.  * paste - a recreation of the Unix(Tm) paste(1) command.
  3.  *
  4.  * syntax:    paste file1 file2 ...
  5.  *        paste -dLIST file1 file2 ...
  6.  *        paste -s [-dLIST] file1 file2 ...
  7.  *
  8.  *    Copyright (C) 1984 by David M. Ihnat
  9.  *
  10.  * This program is a total rewrite of the Bell Laboratories Unix(Tm)
  11.  * command of the same name, as of System V.  It contains no proprietary
  12.  * code, and therefore may be used without violation of any proprietary
  13.  * agreements whatsoever.  However, you will notice that the program is
  14.  * copyrighted by me.  This is to assure the program does *not* fall
  15.  * into the public domain.  Thus, I may specify just what I am now:
  16.  * This program may be freely copied and distributed, provided this notice
  17.  * remains; it may not be sold for profit without express written consent of
  18.  * the author.
  19.  * Please note that I recreated the behavior of the Unix(Tm) 'paste' command
  20.  * as faithfully as possible, with minor exceptions (noted below); however,
  21.  * I haven't run a full set of regression * tests.  Thus, the user of
  22.  * this program accepts full responsibility for any effects or loss;
  23.  * in particular, the author is not responsible for any losses,
  24.  * explicit or incidental, that may be incurred through use of this program.
  25.  *
  26.  * The changes to the program, with one exception, are transparent to
  27.  * a user familiar with the Unix command of the same name.  These changes
  28.  * are:
  29.  *
  30.  * 1) The '-s' option had a bug in the Unix version when used with multiple
  31.  *    files.  (It would repeat each file in a list, i.e., for
  32.  *    'paste -s file1 file2 file3', it would list
  33.  *    <file1\n><file1\n><file2\n><file1\n><file2\n><file3\n>
  34.  *    I fixed this, and reported the bug to the providers of the command in
  35.  *    Unix.
  36.  *
  37.  * 2) The list of valid escape sequences has been expanded to include
  38.  *    \b,\f,\r, and \v.  (Just because *I* can't imagine why you'd want
  39.  *    to use them doesn't mean I should keep them from you.)
  40.  *
  41.  * 3) There is no longer any restriction on line length.
  42.  *
  43.  * I ask that any bugs (and, if possible, fixes) be reported to me when
  44.  * possible.  -David Ihnat (312) 784-4544 ihuxx!ignatz
  45.  */
  46.  
  47. #include <stdio.h>
  48.  
  49. extern int errno;
  50.  
  51. #define CPM
  52.  
  53. /* I'd love to use enums, but not everyone has them.  Portability, y'know. */
  54. #define NODELIM        1
  55. #define USAGE        2
  56. #define BADFILE        3
  57. #define TOOMANY        4
  58.  
  59. #define    TAB        '\t'
  60. #define    NL        '\n'
  61. #define    BS        '\b'
  62. #define    FF        '\f'
  63. #define    CR        '\r'
  64. #define    VT        '\v'
  65. #define    DEL        '\177'
  66.  
  67. #define    _MAXSZ        512
  68. #define _MAXFILES    12
  69. #define    CLOSED        ((FILE *)-1)
  70. #define ENDLIST        ((FILE *)-2)
  71. #define COMMAND        "paste"
  72.  
  73. char *cmdnam;
  74.  
  75. short int dflag,sflag;
  76. char delims[] = { TAB };
  77.  
  78. main(argc,argv)
  79. int argc;
  80. char **argv;
  81. {
  82.     char *strcpy();
  83.  
  84.     dflag = sflag = 0;
  85.  
  86. #ifdef CPM
  87.     cmdnam = COMMAND;
  88. #else
  89.     cmdnam = *argv;
  90. #endif
  91.  
  92.     /* Skip invocation name */
  93.     argv++;
  94.     argc--;
  95.  
  96.     /* First, parse input options */
  97.  
  98.     while(argv[0][0] == '-' && argv[0][1] != '\0')
  99.     {
  100.         switch(argv[0][1])
  101.         {
  102.             case 'd':
  103.             case 'D':
  104.                 /* Delimiter character(s) */
  105.                 strcpy(delims,&argv[0][2]);
  106.                 if(*delims == '\0')
  107.                     prerr(NODELIM,"");
  108.                 else
  109.                     delimbuild(delims);
  110.  
  111.                 break;
  112.  
  113.             case 's':
  114.             case 'S':
  115.                 sflag++;
  116.                 break;
  117.  
  118.             default:
  119.                 prerr(USAGE,"");
  120.         }
  121.         argv++;
  122.         argc--;
  123.     }
  124.  
  125.     /*
  126.      * If no files specified, simply exit.  Otherwise,
  127.      * if not the old '-s' option, process all files.
  128.      * If '-s', then process files one-at-a-time.
  129.      */
  130.     if(!sflag)
  131.         docol(argc,argv); /* Column paste */
  132.     else
  133.         doserial(argc,argv);    /* Serial paste */
  134.  
  135. } 
  136.  
  137. docol(nfiles,fnamptr)
  138. int nfiles;
  139. char **fnamptr;
  140. {
  141.     char iobuff[_MAXSZ];    /* i/o buffer for the fgets */
  142.     short int somedone;    /* flag for blank field handling */
  143.  
  144.     /*
  145.      * There is a strange case where all files are just ready to
  146.      * be closed, or will on this round.  In that case, the string
  147.      * of delimiters must be preserved.  delbuf[1] ->delbuf[MAXFILES+1]
  148.      * provides intermediate storage for closed files, if needed;
  149.      * delbuf[0] is the current index.
  150.      */
  151.     char delbuf[_MAXFILES+2];
  152.  
  153.     FILE *fileptr[_MAXFILES+1];
  154.     FILE *fopen();
  155.  
  156.     char *fgets();
  157.  
  158.     int filecnt;            /* Set to number of files to process */
  159.     register char *delimptr;    /* Cycling delimiter pointer */
  160.     int index;            /* Working variable */
  161.     int strend;            /* End of string in buffer */
  162.  
  163.     /*
  164.      * Perform column paste.  First, attempt to open all
  165.      * files. (This could be expanded to an infinite number of files,
  166.      * but at the (considerable) expense of remembering the file and
  167.      * its current offset, then opening/reading/closing.  The
  168.      * commands' utility doesn't warrant the effort; at least, to me...)
  169.      */
  170.  
  171.     for(filecnt=0;(nfiles>0) && (filecnt<_MAXFILES);filecnt++,nfiles--,fnamptr++)
  172.     {
  173.         if(fnamptr[0][0] == '-')
  174.             fileptr[filecnt] = stdin;
  175.         else
  176.         {
  177.             fileptr[filecnt] = fopen(*fnamptr,"r");
  178.             if(fileptr[filecnt] == NULL)
  179.                 prerr(BADFILE,*fnamptr);
  180.         }
  181.     }
  182.  
  183.     fileptr[filecnt] = ENDLIST;    /* End of list. */
  184.  
  185.     if(nfiles)
  186.         prerr(TOOMANY,"");
  187.  
  188.     /*
  189.      * Have all files.  Now, read a line from each file, and output
  190.      * to stdout.  Notice that the old 511 character limitation on
  191.      * the line length no longer applies, since this program doesn't
  192.      * do the buffering.  Do this until you go through the loop and
  193.      * don't successfully read from any of the files.
  194.      */
  195.     for(;filecnt;)
  196.     {
  197.         somedone = 0;        /* Blank field handling flag */
  198.         delimptr = delims;    /* Start at beginning of delim list */
  199.         delbuf[0] = 0;        /* No squirreled delims */
  200.  
  201.         for(index = 0;(fileptr[index] != ENDLIST) && filecnt; index++)
  202.         {
  203.             /* Read a line and immediately output.
  204.              * If it's too big for the buffer, then dump what was
  205.              * read and go back for more.
  206.              *
  207.              * Otherwise, if it is from the last file, then leave
  208.              * the carriage return in place; if not, replace with
  209.              * a delimiter (if any)
  210.              */
  211.  
  212.             strend = 0;    /* Set so can easily detect EOF */
  213.  
  214.             if(fileptr[index] != CLOSED)
  215.  
  216.                 while(fgets(iobuff,(_MAXSZ-1),fileptr[index]) != (char *)NULL)
  217.                 {
  218.                     strend = strlen(iobuff);    /* Did the buffer fill? */
  219.  
  220.                     if(strend == (_MAXSZ-1))
  221.                     {
  222.                         /* Gosh, what a long line. */
  223.                         fputs(iobuff,stdout);
  224.                         strend = 0;
  225.                         continue;
  226.                     }
  227.  
  228.                     /* Ok got whole line in buffer. */
  229.                     break;    /* Out of loop for this file */
  230.                 }
  231.  
  232.             /* Ended either on an EOF (well, actually NULL return--
  233.              * it *could* be some sort of file error, but
  234.              * but if the file was opened successfully, this is
  235.              * unlikely. Besides, error checking on streams
  236.              * doesn't allow us to decide exactly what went
  237.              * wrong, so I'm going to be very Unix-like and ignore
  238.              * it!), or a closed file, or a received line.
  239.              * If an EOF, close the file and mark it in the
  240.              * list.  In any case, output the delimiter of choice.
  241.              */
  242.  
  243.             if(!strend)
  244.             {
  245.                 if(fileptr[index] != CLOSED)
  246.                 {
  247.                     fclose(fileptr[index]);
  248.                     fileptr[index] = CLOSED;
  249.                     filecnt--;
  250.                 }
  251.  
  252.                 /* Is this the end of the whole thing? */
  253.                 if((fileptr[index+1] == ENDLIST) && !somedone)
  254.                     continue; /* EXITS */
  255.  
  256.                 /* Ok, some files not closed this line. Last file? */
  257.                 if(fileptr[index+1] == ENDLIST)
  258.                 {
  259.                     if(delbuf[0])
  260.                     {
  261.                         fputs(&delbuf[1],stdout);
  262.                         delbuf[0] = 0;
  263.                     }
  264.                     putc((int)NL,stdout);
  265.                     continue;    /* Next read of files */
  266.                 }else
  267.                 {
  268.                     /* Closed file; setup delim */
  269.                     if(*delimptr != DEL)
  270.                     {
  271.                         delbuf[0]++;
  272.                         delbuf[delbuf[0]] = *delimptr++;
  273.                         delbuf[delbuf[0]+1] = '\0';
  274.                     }else
  275.                         delimptr++;
  276.                 }
  277.  
  278.                 /* Reset end of delimiter string if necessary */
  279.                 if(*delimptr == '\0')
  280.                     delimptr = delims;
  281.             }else
  282.             {
  283.                 /* Some data read. */
  284.                 somedone++;
  285.  
  286.                 /* Any saved delims? */
  287.                 if(delbuf[0])
  288.                 {
  289.                     fputs(&delbuf[1],stdout);
  290.                     delbuf[0] = 0;
  291.                 }
  292.  
  293.                 /* If last file, last char will be NL. */
  294.                 if(fileptr[index+1] != ENDLIST)
  295.                 {
  296.                     if(*delimptr == DEL)
  297.                     {
  298.                         delimptr++;
  299.                         iobuff[strend-1] = '\0'; /* No delim */
  300.                     }else
  301.                         iobuff[strend-1] = *delimptr++;
  302.                 }
  303.  
  304.                 if(*delimptr == '\0')
  305.                     delimptr = delims;
  306.  
  307.                 /* Now dump the buffer */
  308.                 fputs(iobuff,stdout);
  309.             }
  310.         }
  311.     }
  312. }
  313.  
  314. doserial(nfiles,fnamptr)
  315. int nfiles;
  316. char **fnamptr;
  317. {
  318.     /*
  319.      * Do serial paste.  Simply scarf characters, performing
  320.      * one-character buffering to facilitate delim processing.
  321.      */
  322.     
  323.     register int charnew,charold;
  324.     register char *delimptr;
  325.  
  326.     register FILE *fileptr;
  327.     FILE *fopen();
  328.  
  329.     for(;nfiles;nfiles--,fnamptr++)
  330.     {
  331.         if(fnamptr[0][0] == '-')
  332.             fileptr = stdin;
  333.         else
  334.         {
  335.             fileptr = fopen(*fnamptr,"r");
  336.  
  337.             if(fileptr == NULL)
  338.                 prerr(BADFILE,*fnamptr);
  339.         }
  340.  
  341.         /*
  342.          * The file is open; just keep taking characters,
  343.          * stashing them in charnew; output charold, converting to
  344.          * the appropriate delimiter character if needful.  After the
  345.          * EOF, simply output 'charold' if it's a newline; otherwise,
  346.          * output it and then a newline.
  347.          */
  348.  
  349.         delimptr = delims;    /* Set up for delimiter string */
  350.  
  351.         if((charold = getc(fileptr)) == EOF)
  352.         {
  353.             /* Empty file! */
  354.             putc(NL,stdout);
  355.             continue;    /* Go on to the next file */
  356.         }
  357.  
  358.         /* Ok, 'charold' is set up.  Hit it! */
  359.  
  360.         while((charnew = getc(fileptr)) != EOF)
  361.         {
  362.             /* Ok, process the old character */
  363.             if(charold == NL)
  364.             {
  365.                 if(*delimptr != DEL)
  366.                     putc(*delimptr++,stdout);
  367.  
  368.                 /* Reset pointer at end of delimiter string */
  369.                 if(*delimptr == '\0')
  370.                     delimptr = delims;
  371.             } else
  372.                 putc((char)charold,stdout);
  373.             
  374.             charold = charnew;
  375.         }
  376.  
  377.         /* Ok, hit EOF.  Process that last character */
  378.  
  379.         putc((char)charold,stdout);
  380.  
  381.         if((char)charold != NL)
  382.             putc(NL,stdout);
  383.     }
  384. }
  385.  
  386. delimbuild(strptr)
  387. char *strptr;
  388. {
  389.     /*
  390.      * Process the delimiter string into something that can be
  391.      * used by the routines.  This involves, primarily, collapsing
  392.      * the backslash representations of special characters into
  393.      * their actual values, and terminating the string in a manner
  394.      * that the routines can recognize.  The set of possible backslash
  395.      * characters has been expanded beyond that recognized by the
  396.      * vanilla Unix(Tm) version.
  397.      */
  398.     register char *strout;
  399.  
  400.     strout = strptr;    /* Start at the same place, anyway */
  401.  
  402.     while(*strptr)
  403.     {
  404.         if(*strptr != '\\')    /* Is it an escape character? */
  405.             *strout++ = *strptr++;    /* No, just transfer it */
  406.         else
  407.         {
  408.             strptr++;    /* Get past escape character */
  409.             switch(*strptr)
  410.             {
  411.                 case '0':
  412.                     *strout++ = DEL;
  413.                     break;
  414.  
  415.                 case 't':
  416. #ifdef CPM
  417.                 case 'T':
  418. #endif
  419.                     *strout++ = TAB;
  420.                     break;
  421.  
  422.                 case 'n':
  423. #ifdef CPM
  424.                 case 'N':
  425. #endif
  426.                     *strout++ = NL;
  427.                     break;
  428.  
  429.                 case 'b':
  430. #ifdef CPM
  431.                 case 'B':
  432. #endif
  433.                     *strout++ = BS;
  434.                     break;
  435.  
  436.                 case 'f':
  437. #ifdef CPM
  438.                 case 'F':
  439. #endif
  440.                     *strout++ = FF;
  441.                     break;
  442.  
  443.                 case 'r':
  444. #ifdef CPM
  445.                 case 'R':
  446. #endif
  447.                     *strout++ = CR;
  448.                     break;
  449.  
  450.                 case 'v':
  451. #ifdef CPM
  452.                 case 'V':
  453. #endif
  454.                     *strout++ = VT;
  455.                     break;
  456.  
  457.                 default:
  458.                     *strout++ = *strptr;
  459.             }
  460.             
  461.             strptr++;
  462.         }
  463.  
  464.     }
  465.     *strout = '\0';    /* Heaven forfend that we forget this! */
  466. }
  467.  
  468. prerr(etype, estring)
  469. int etype;
  470. char *estring;
  471. {
  472.     switch(etype)
  473.     {
  474.         case USAGE:
  475.             fprintf(stderr,"%s : Usage: %s [-s] [-d<delimiterstring>] file1 file2 ...\n",cmdnam,cmdnam);
  476.             break;
  477.  
  478.         case NODELIM:
  479.             fprintf(stderr,"%s : no delimiters\n",cmdnam);
  480.             break;
  481.  
  482.         case BADFILE:
  483.             fprintf(stderr,"%s : %s : cannot open\n",cmdnam,estring);
  484.             break;
  485.         
  486.         case TOOMANY:
  487.             fprintf(stderr,"%s : too many files\n",cmdnam);
  488.             break;
  489.     }
  490.     exit(1);
  491. }
  492.